Credit and Loan Approval Classification Using a Bio-Inspired Neural Network

Numerous people are applying for bank loans as a result of the banking industry’s expansion, but because banks only have a certain amount of assets to lend to, they can only do so to a certain number of applicants. Therefore, the banking industry is very interested in finding ways to reduce the risk factor involved in choosing the safe applicant in order to save lots of bank resources. These days, machine learning greatly reduces the amount of work needed to choose the safe applicant. Taking this into account, a novel weights and structure determination (WASD) neural network has been built to meet the aforementioned two challenges of credit approval and loan approval, as well as to handle the unique characteristics of each. Motivated by the observation that WASD neural networks outperform conventional back-propagation neural networks in terms of sluggish training speed and being stuck in local minima, we created a bio-inspired WASD algorithm for binary classification problems (BWASD) for best adapting to the credit or loan approval model by utilizing the metaheuristic beetle antennae search (BAS) algorithm to improve the learning procedure of the WASD algorithm. Theoretical and experimental study demonstrate superior performance and problem adaptability. Furthermore, we provide a complete MATLAB package to support our experiments together with full implementation and extensive installation instructions.


Introduction
Since the turn of the century, banks and other financial institutions have been granting loans.Given that credit risk emerges mostly when borrowers are unable or unwilling to pay, rigorous background screening of a customer prior to approval of a loan failing is an essential necessity to sustain oneself in such a business [1,2].Keep in mind that the amount of non-performing loans in the economy is significant because these loans weigh on bank profits and use valuable resources, limiting banks' ability to grant new loans [3,4].Problems in the banking sector can swiftly spread to other sections of the economy, jeopardizing employment and economic growth [5,6].As a result, there is an urgent need to develop better models for determining whether or not to grant a loan [7,8].
These days, emerging technologies like machine learning and natural language processing greatly reduce the amount of work needed to do such tasks [9][10][11].Machine learning tasks involving classification are typically found in several fields, such as engineering [12,13], medicine [14], finance and economics [15,16].Classification presents a significant challenge in these fields.
Neural networks (NNs), which are mostly used for classification and regression challenges, have been effectively implemented in several fields, including medicine, engineering, economics, social science research and finance.In engineering, they are widely used for alloy behavior analysis [17], solar systems measurements [18], and feedback control systems stabilization [19].Additionally, NNs are frequently used in medical diagnostics to diagnose flat foot [20], diabetic retinopathy [21], and various cancers, such as breast cancer [14] and lung cancer [22].In contrast, NNs are typically used in the fields of economics and finance for macroeconomic factor prediction [23,24], time series forecasting [25,26], and portfolio optimization [27].Furthermore, NNs have been effectively used in social science investigation, typically for multiclass classification challenges like classifying occupations [28], assessing the possibility for teleworking in jobs [29], and defining occupational mobility [30].
The primary goal of this work is to create a model for predicting loan acceptance utilizing novel NNs enhanced with state-of-the-art metaheuristic optimization techniques.We will use a feed-forward NN that can handle binary classification tasks in order to achieve this.A training algorithm called weights and structure determination (WASD) will be used in place of the well-known back-propagation approach for training feed-forward NNs.Unlike the back-propagation technique, which iteratively changes the network's structure, the WASD approach uses the weights direct determination (WDD) procedure to compute the optimal set of weights directly.In the end, this reduces computational complexity by preventing the system from becoming trapped in local minima [31].Taking into account the multi-input with multi-function activated WASD (MWASD) algorithm for binary classification proposed in [15], the metaheuristic beetle antennae search (BAS) algorithm is paired with the MWASD concept in this work to further improve the performance and structure of the WASD based NNs.In this way, we present a bio-inspired WASD (BWASD) algorithm for binary classification challenges to train a 3-layer feed-forward NN.It is important to note that BAS, which can perform efficient global optimization, has recently gained significant traction in several scientific domains, such as finance [32], robotics [33,34], engineering [35,36], and machine learning [19].To better address these tasks, BAS has undergone a number of alternations, such as the binary [37] and the semiinteger [38] acceptations.Specifically in machine learning, the WASD and BAS algorithms have been combined in [32] to improve the performance and structure of WASD based NNs for regression-related challenges.Unlike [32], which simply uses the BAS-WASD combination to determine the best structure of the NN in regression-related situations, our approach utilizes BWASD: 1.
to identify the ideal structure of the NN; 2.
to find the optimal activation function of each hidden layer neuron in binary classification tasks; 3.
and to do cross-validation auto-adjustment (i.e., optimize the ratio between the fitting and validation sets).
Results from four experiments demonstrate that the BWASD model outperforms several of the most advanced models of MATLAB's classification learner in every way.The primary ideas of this work can be summed up as follows: • A novel 3-layer feed-forward bio-inspired WASD NN for binary classifications, termed BWASD, is presented.

•
The BWASD algorithm merges the BAS and MWASD processes to further improve the performance and structure of the WASD based NNs.

•
Taking into account four loan approval datasets, the performance of the MWASD and BWASD models is contrasted.

•
Several of the most advanced models of MATLAB's classification learner are compared with the BWASD model in four experiments.
The structure of the paper is described in the following sections.Section 2 provides an overview of the WDD procedure for binary classification tasks.The 3-layer feed-forward BWASD NN structure, the BWASD algorithm and the whole process for training and the procedure for testing the BWASD NN model are presented in Section 3. Section 4 shows and discusses the findings of four loan approval datasets using the BWASD, the MWASD and several of the most cutting-edge models of MATLAB's classification learner.Final remarks are provided in Section 5.

A Novel Weights Direct Determination (WDD) Process for Binary Classification
The WDD process is an essential component of any WASD technique since it eliminates the need for laborious, time-consuming, and frequently erroneous repeating computations to obtain the appropriate weights matching the current hidden layer structure.The WDD approach is claimed to offer reduced computing complexity and speed compared to traditional weight determination methods, while also resolving certain related issues [31].It is important to note that real numbers are the sole type of input data that the WDD accepts.Prior to being fed into the NN model, the data must additionally be standardized to a range of [−0.5, −0.25].The NN can manage over-fitting in this way.We can achieve it, if necessary, by using the linear transformation that is illustrated in [26].
In this section, comprehensive explanations of important scientific and theoretical underpinnings are provided in support of the creation of the BWASD NN.But before anything else, it is important to recognize some of the key symbols used in this paper: Transposition is indicated by () T ; factorial of η is indicated by η!; pseudoinversion is shown by () † ; elementwise exponential is indicated by () ⊙ ; round function is indicated by R(•).
The theorem of the approximation of the Taylor polynomial (ATP) from [39] is restated below.
Consider the input C = [C 1 , C 2 , . . ., C m ] ∈ R 1×m and the target J ∈ R. The nonlinear function shown next can be utilized to define the relationship between the input variables C 1 , C 2 , . . ., C m and the NN's output target J, based on the multi-input NNs described in [31]: The map between the ρ-order ATP U ρ (C 1 , C 2 , . . ., C m ) and (4), inline with Proposition 1, appears below: where a power activation function is denoted by k h = A h (C 1 , C 2 , . . ., C m ) ∈ R 1×mn ; the weight associated with k h is denoted by w h ∈ R mn ; and h denotes both the number of hidden layer neurons and the power value.When r ∈ N samples are taken, the target becomes J ∈ R r and the input matrix becomes C = [C 1 , C 2 , . . ., C m ] ∈ R r×m , where C j ∈ R r for j = 1, . . ., m.Then, with k r,h = A h (C 1 , C 2 , . . ., C m ) ∈ R r×mn , the weight vector W and the input-activation matrix K appear below: Afterwards, instead of employing the iterative weight training techniques employed in traditional NNs, the weights of the ρ-order ATP NN are created by executing the WDD methodology laid out below [39]: Furthermore, Table 1 presents the four power elementwise activation functions extracted from [26], which are suggested for use in binary classification tasks.
Table 1.Options of power activation functions.

The Bio-Inspired WASD (BWASD) Model
This section features the 3-layer feed-forward NN structure and the BWASD algorithm.

The Neural Network Structure
Figure 1 illustrates the architecture of the 3-layer feed-forward NN.Specifically, the NN finds the appropriate neuron of Layer 2 with equal weight 1 after receiving the normalized input values C 1 , C 2 , . . ., C m from Layer 1 (i.e., the input layer).Note that Layer 2 contains a maximum of n active neurons.Moreover, the WDD process is used to acquire the neurons that link Layer 2 and Layer 3 (i.e., the output layer), and these neurons have weights W j , j = 1, 2, . . ., n − 1.Using the following formula, the predictions Ĵ are computed: Finally, Layer 3 has a single active neuron that utilizes the elementwise function outlined below: where the numbers 0 and 1, respectively, stand for false and true in order to identify something as true or false depending on the related input C of the first layer.Also, notice that the number −0.375 is the midpoint of the interval [−0.5, −0.25].

The BWASD Algorithm
The BWASD algorithm, which incorporates the BAS algorithm [40], is responsible for training the NN model.It should be noted that beetles use both of their antennae to search for food, depending on how strong the scent is that they detect on them (Figure 2).This tendency is mimicked by the optimal solution finder of the BAS algorithm, and this approach allows the use of state-of-the-art techniques for optimization (see [41][42][43]).BWASD mimics the behavior of the beetle to find the optimal number of hidden layer neurons in the NN, their power value, and the optimal activation function from Table 1 for each hidden layer neuron.It does this by optimizing the ratio between the fitting and validation sets (i.e., cross-validation auto-adjustment).First, an objective function must be defined.Consider the training set X tr ∈ R r×m with r in number samples and their target J tr ∈ R r .The parameter p ∈ [0.3, 0.95] ⊆ R determines the ratio between the fitting and the validation set.Particularly, the first r 1 = pr samples of X tr are used for fitting the model and the last r 2 = r − r 1 samples for validation.That is, X f i ∈ R r 1 ×m is the fitting set and X va ∈ R r 2 ×m is the validation set, while J f i ∈ R r 1 and J va ∈ R r 2 are their target, respectively.Keep in mind that validation aids in ensuring that the model's success generalizes beyond the training set because it is separate from the fitting set.Then, the K matrix is constructed according to Algorithm 1 proposed in [15], which makes use the power activation function in Table 1.For the fitting set X f i , the weights of the NN W are directly obtained by (7) using K(1 : r 1 ) and J f i .For the validation set X va , the NN predictions Ĵva are obtained by (8) using K(r 1 + 1 : r) and W, and the mean absolute error (MAE) between the target J va and Ĵva is gauged via the next formula:

B e e t l e S e a r c h i n g B e h a v i o r : • a t e a c h s t e p t , g a u g e t h e s t r e n g t h o f t h e o d o r • c o mp a r e t h e i n t e n s i t y o f t h e o d o r , f ( x ) , t o r e c k o n a d i r e c o n t o wa r d s t h e f o o d s o u r c e • mo v e i n t h a t d i r e c o n b y a s i z e s t e p ξ t t h a t c o r r e s p o n d s t o t h e i n t e n s i t y d i ff e r e n c e
It should be noted that the MAE is widely used in machine learning as a loss function for classification challenges, and that it counts errors between paired observations that represent the same situation.Assume the vector x = [p, c, N] T , where N is a vector that includes the hidden layer neurons' power values and c is a vector that contains the numbering of the optimal activation function from Table 1 for each hidden layer neuron.
In Algorithm 1, the previously indicated procedure is expressed as an objective function.

Require:
The vector x, the input data X and the target J.
1: procedure OB_FUNC(X, J, Split x into p, c and N, and set r the rows number of X.

3:
Keep only the nonnegative elements in N and in c only their corresponding activation function numbering.

4:
Calculate the matrix K through Algorithm 1 proposed in [15] under the N and c.

6:
Through the WDD method, calculate W utilizing K(1 : r 1 ) and J f i .

8:
Through (10), assign the MAE that was calculated between Ĵva and J va to E. 9: end procedure Ensure: E, the error.
Second, by adopting the beetle's behavior, the objective function in Algorithm 1 is minimized.Consider the vector x = [p, c T , N T ] T , where the parameter p ∈ [0.3, 0.95], and c is a vector of variable size and its elements take the integer values 1, 2, 3 or 4.These 4 numbers correspond to the activation functions presented in Table 1.Also, the vector N has the same size as c and its entries take the integer values 0, 1, . . ., n max − 1 or n max .Take note that n max is the maximum number of hidden layer neurons that the user has set.These n max + 1 values represent the power of the activation functions for every neuron in the hidden layer.For instance, c = [2, 4] T and N = [9,6] T indicate the presence of two hidden layer neurons, the first of which operates under the power of 9 using the power sigmoid activation function and the second under the power of 6 using the power softplus activation function.
The beetle's position is represented by the previously described vector x in our method, and the odor concentration at position x is represented by the objective function f (x) in Algorithm 1.The minimal value of f (x) acts as a link to the source of the odor.In addition, we use the notation x t with t = 1, 2, 3, . . ., t max , where t max indicates the maximum number of iterations that the user specifies, to denote the position of the beetle at the t-th moment.As a result, we set the lower boundary LB = [0.3, 1 T , 0 T ] T , where 1, 0 ∈ R n max +1 denote the all ones and all zeros vectors, respectively, and the upper boundary UB = [0.9, In order to guarantee that LB ≤ x ≤ UB, the following element-wise function will be used for the element j = 1, . . ., 2n max + 1: Thus, a model of searching behavior is defined by the beetle's chaotic search path in the following manner: where γ ∈ R 2n max +1 implies a random vector of 2n max + 1 entries and ϵ = 2 −52 .The following formulas are used to create the left (x L ) and right (x R ) antennae, which simulate the beetle's antennae's searching behaviors: where the sensing width of the antennae, η t , corresponds to the exploit's capacity at the t-th moment.Furthermore, take into account the potential best solution (x P ): where the notation ξ t represents a step size that accounts for the rate of convergence after a rise in t across the search.Next, the detecting behavior is stated as follows: Finally, the following describes the update rules for η and ξ: It is important to remember that the prerequisites for the previously given technique are as follows: where q = R((2n max + 1)/2).After that, on the complete training data set, the BWASD algorithm finds and outputs the optimal: ratio p * between the fitting and validation sets; the optimal W; the optimal power value N * ; and the optimal activation function of each hidden layer neuron c * .The full workflow of the BWASD algorithm is illustrated in the diagram of Figure 3a.
Once finding the optimal structure of BWASD NN model of Figure 1, its optimal weights and parameters p * , N * , c * , we set the testing set X te to find the predictions B( Ĵte ) via (9).The diagram presented in Figure 3b provides an illustration of the comprehensive process for modeling and prediction using the BWASD NN model.

Experiments
In this section, four datasets are used to conduct four different experiments on credit and loan approval.In these experiments, the performance of the BWASD NN is examined and compared with several top-performing models of MATLAB's classification learner.The kernel naive Bayes (KNB), fine tree (FTR), linear support vector machine (LSVM), and fine k-nearest neighbors (FKNN) are these classification models.The MWASD NN model developed in [15] is also compared because BWASD is an enhanced version of MWASD.For the BWASD model, we have used η 0 = ξ 0 = 5, t max = 21, and n max = 10; for the MWASD model, we have used n max = 10 and p = 0.8; and for the MATLAB classification models, we have used the default values.It is noteworthy that by clicking the next GitHub link, anyone can obtain the entire development and implementation of the ideas and computation techniques discussed in Sections 2-4: https://github.com/SDMourtas/BWASD(accessed on 10 January 2024).Be aware that the MATLAB toolbox includes implementation and installation guidance.

Dataset 1
Customer information entered on an online loan application form is included in the dataset used in this experiment.You may access the dataset, which we will refer to as DA1, by clicking on the provided link: https://www.kaggle.com/datasets/ninzaami/loan-predication?resource=download (accessed on 10 January 2024).It is important to mention that DA1 was provided by a business that wants to automate the real-time loan qualifying process using customer information.DA1 will contain 471 numerical samples under 13 variables when the data preprocessing algorithm described in [15] is used.As a result, the training set is constructed using the first 236 samples, while the testing set is constructed using the final 235 samples.
The BWASD training error is shown in Figure 4a, while the NNs classification results for the training and testing sets are displayed in Figures 4b,c, respectively.Figure 4a shows that the validation error is higher than the fitting error, and that the BWASD requires 20 iterations to optimize the NN structure.Particularly, BWASD returned N * = [3, 1, 3, 4] with c * = [3, 2, 2, 1] and p * = 0.3 for the specific run, while MWASD returned N * = [0, 1] with c * = [1,3].That is, the NN trained under BWASD has 4 hidden layer neurons, while the NN trained under MWASD has 2. Figure 4b shows that FKNN has the best ratio correct/incorrect classifications on the training set, whereas KNB has the worst.Figure 4c shows that BWASD has the best ratio correct/incorrect classifications on the testing set, while FKNN and KNB have the worst.

Dataset 2
The dataset used in this experiment includes results based on credit rating algorithms as well as the possibility that someone may have financial issues in the next two years.It is important to mention that banks ussualy utilize credit scoring algorithms to assess whether to approve a loan based on an estimation of the likelihood of default.You may access the dataset, which we will refer to as DA2, by clicking on the provided link: https:// www.kaggle.com/brycecf/give-me-some-credit-dataset?select=cs-training.csv (accessed on 10 January 2024).DA2 will contain 120269 numerical samples under 11 variables when the data preprocessing algorithm described in [15] is used.As a result, the training set is constructed using the first 9179 samples, while the testing set is constructed using the final 111090 samples.
The BWASD training error is shown in Figure 5a, while the NNs classification results for the training and testing sets are displayed in Figures 5b,c, respectively.Figure 5a shows that the validation error is higher than the fitting error, and that the BWASD requires 10 iterations to optimize the NN structure.Particularly, BWASD returned N * = [0, 0, 3, 3, 4, 6] with c * = [4,3,3,4,2,3] and p * = 0.9 for the specific run, while MWASD returned 3,4,3,4].That is, the NN trained under BWASD has 6 hidden layer neurons, while the NN trained under MWASD has 5. Figure 5b shows that FKNN has the best ratio correct/incorrect classifications on the training set, whereas KNB has the worst.Figure 5c shows that LSVM has the best ratio correct/incorrect classifications on the testing set and BWASD has the second best, while KNB has the worst.

Dataset 3
Numerous credit card applications are received by commercial banks.Many of them are turned down for a variety of reasons, such as excessive credit record requests, poor income, or large loan balances.Because time is money, manually assessing these applications is tedious, prone to errors, and time-consuming.Fortunately, machine learning can be used to automate this operation, and most commercial banks already do so.The dataset used in this experiment includes results of credit card applications.You may access the dataset, which we will refer to as DA3, by clicking on the provided link: https://www.kaggle.com/datasets/samuelcortinhas/credit-card-approval-clean-data(accessed on 10 January 2024).DA3 will contain 689 numerical samples under 16 variables when the data preprocessing algorithm described in [15] is used.As a result, the training set is constructed using the first 345 samples, while the testing set is constructed using the final 344 samples.
The BWASD training error is shown in Figure 6a, while the NNs classification results for the training and testing sets are displayed in Figures 6b,c, respectively.Figure 6a shows that the validation error is mostly higher than the fitting error, and that the BWASD requires 21 iterations to optimize the NN structure.

Dataset 4
Banks require decision-making guidelines regarding which loans they will approve or deny in order to reduce their own losses.Loan managers take into account an applicant's socioeconomic and demographic profiles before making a determination about the loan application.The dataset used in this experiment includes results of loan applications based on applicants socioeconomic and demographic profiles.You may access the dataset, which we will refer to as DA4, by clicking on the provided link: https://www.kaggle.com/datasets/mpwolke/cusersmarildownloadsgermancsv (accessed on 10 January 2024).DA4 will contain 999 numerical samples under 20 variables when the data preprocessing algorithm described in [15] is used.As a result, the training set is constructed using the first 500 samples, while the testing set is constructed using the final 499 samples.
The BWASD training error is shown in Figure 7a, while the NNs classification results for the training and testing sets are displayed in Figures 7b,c, respectively.Figure 7a shows that the validation error is higher than the fitting error, and that the BWASD requires 2 iterations to optimize the NN structure.Particularly, BWASD returned N * = [0, 2, 3, 3, 2, 4] with c * = [4, 1, 1, 1, 1, 4] and p * = 0.95 for the specific run, while MWASD returned N * = [0, 1, 2] with c * = [4,3,3].That is, the NN trained under BWASD has 6 hidden layer neurons, while the NN trained under MWASD has 3. Figure 7b shows that FKNN has the best ratio correct/incorrect classifications on the training set, whereas KNB has the worst.Figure 7c shows that BWASD has the best ratio correct/incorrect classifications on the testing set, while FTR has the worst.

Performance Measures and Discussion
The models statistics for DA1-DA4 on the testing set are shown in Tables 2-5, correspondingly.The MAE, true positive (TP), true negative (TN), false positive (FP), false negative (FN), precision, recal, accuracy and F-score are the performance gauges considered in this analysis.Consult [44] for further information and a detailed examination of these gauges.Additionally, the accuracy of the classification models is statistically evaluated the mid-p-value McNemar test in Tables 6-8.In Table 2, BWASD appears to have the finest MAE, accuracy and F-score, and the second finest TP, FP, precision and recal.FTR has the best TN, FN and recal, and the worst TP, FP, and precision.The results of MWASD and LSVM are identical and they have the best TP, FP, and precision.Additionally, KNB has the worst MAE, TN, FN, recal, accuracy and F-score.According to the aforementioned statistics, the performance of BWASD is the best, while KNB is the poorest.
In Table 5, BWASD appears to have the finest MAE, accuracy and F-score, the second finest recall, and the third finest TP, FP, TN, FN and precision.KNB has the best TP, FP and precision, FTR has the best TN and FN, and MWASD has the best recal.LSVM has the best TP, FP and precision.Additionally, FTR has the worst MAE, TP, FP, precision, accuracy and F-score, whereas KNB has the worst TN, FN and recal.According to the aforementioned statistics, the performance of BWASD is the best, while FTR is the poorest.
The BWASD model is compared to all other models in Tables 6-8 using the mid-p-value McNemar test to statistically evaluate the classification models' accuracies.The McNemar test is a form of homogeneity test that applies to contingency tables and is a distribution-free statistical hypothesis test.The test determines whether the binary classification models' accuracies differ or whether one binary classification model outperforms the other.We perform the McNemar test specifically using the MATLAB function testcholdout, as described in [45,46].It is important to note that the simulation experiments in [45][46][47] show that this test has good statistical power and achieves nominal coverage.The statistical analysis in this subsection follows the recommendations in [47].According to the marginal homogeneity null hypothesis, each outcome's two marginal probabilities are equal.In our investigation, the null hypothesis claims that the accuracy of the predicted class labels from the NN model Z and the BWASD is equal, where Z refers to MWASD, FKNN, FTR, LSVM or KNB.Additionally, we consider the following three alternative hypothesis (AH): • AH1: For predicting the class labels, the NN model Z and the BWASD have unequal accuracies.• AH2: For predicting the class labels, the NN model Z is more accurate than the BWASD.• AH3: For predicting the class labels, the NN model Z is less accurate than the BWASD.
In this way, we conduct three McNemar tests under three different alternative hypothesis to assess.Each test determines whether to reject or not to reject the null hypothesis at the 5% significance level.Keep in mind that an outcome is considered statistically significant if it allows us to reject the null hypothesis, and that lower p-values (usually ≤ 0.05) are seen as more convincing proof to reject the null hypothesis.Table 6 shows the McNemar's test results for AH1.In DA1, DA3 and DA4, when comparing BWASD to Z = {FKNN, FTR, KNB}, a p-value of almost zero from the McNemar test indicates that there is enough proof to reject the null hypothesis.In other words, the predicted accuracies of the Z and BWASD models are not equal.On the other hand, when comparing BWASD to Z = {MWASD, LSVM}, a p-value that is far from zero indicates that there is enough proof to not reject the null hypothesis.In other words, the predicted accuracies of the Z and BWASD models are equal.In DA2, when comparing BWASD to Z = {MWASD, FKNN, FTR, LSVM, KNB}, a p-value of almost zero indicates that there is enough proof to reject the null hypothesis.In other words, the predicted accuracies of the Z and BWASD models are not equal.
Table 7 shows the McNemar's test results for AH2.In DA1, DA3 and DA4, when comparing BWASD to Z = {MWASD, FKNN, FTR, KNB, LSVM}, a p-value of one or almost one from the McNemar test indicates that there is not enough proof to reject the null hypothesis.In other words, the predicted accuracies of the Z and BWASD models are equal.In DA2, when comparing BWASD to Z = {MWASD, FKNN, FTR, KNB}, a p-value of one or almost one indicates that there is not enough proof to reject the null hypothesis.In other words, the predicted accuracies of the Z and BWASD models are equal.However, when comparing BWASD to Z = {LSVM}, a p-value of zero indicates that there is enough proof to reject the null hypothesis.In other words, the Z model is more accurate than the BWASD.
Table 8 shows the McNemar's test results for AH3.In DA1, DA3 and DA4, when comparing BWASD to Z = {FKNN, FTR, KNB}, a p-value of almost zero from the McNemar test indicates that there is enough proof to reject the null hypothesis.In other words, the Z model is less accurate than the BWASD.On the other hand, when comparing BWASD to Z = {MWASD, LSVM}, a p-value that is far from zero indicates that there is enough proof to not reject the null hypothesis.In other words, the predicted accuracies of the Z and BWASD Therefore, based on Tables 2-8 statistics, we conclude that the BWASD is the best performing model in DA1-DA4.In broad terms, the BWASD model consistently provided great results in the classification of loan approval tasks, and it performs rather well when compared to traditional NN models.Therefore, the BWASD model can be beneficial for various businesses.These include businesses looking to automate the evaluation of loan applications based on customer information, banks evaluating credit card applications, banks evaluating loan applications based on an estimation of the likelihood of default, and banks evaluating loan applications based on the socioeconomic and demographic profiles of applicants.

Conclusions
This work presents a bio-inspired WASD NN for binary classification challenges, named BWASD.The findings of experiments in four loan approval datasets demonstrate that the BWASD model performs better than the MWASD model and several cutting-edge models of MATLAB's classification learner.Therefore, the BWASD model has shown to be an excellent stand-in for determining whether or not to approve a loan.It is significant to note that the BWASD NN model can only be trained and tested using actual numerical data as input due to restrictions imposed by the WDD method.Future research will therefore focus on properly adjusting and applying it to other binary classification challenges across multiple scientific disciplines.
In this context, the BWASD model could be modified for use in the engineering domain to analyze alloy behavior or data from solar systems, as shown in [17,18].The BWASD model could also be adjusted for use in the medicine domain to analyze diagnostic data, as demonstrated in [21].Finally, integrating BAS alternations, like [37,38], may help to improve the accuracy of the BWASD model even further.

Figure 1 .
Figure 1.Structure of the BWASD neural network.
f(xP) < f(xt)?xt+1 ← xP Update ξ and ζ through Equation (16), and set t ← t+1 Yes t ≤ tmax?No No Yes xt+1 ← xi Calculate xP via Equation (14) Set h ← Equation (12), and xL, xR ← Equation (13) Initialize via Equation (17) Return the optimal x*← xt (a) BWASD algorithm.Input Data Return B(Ĵte) via Equation (9) Construct the Xtr, Xte, Jtr, and Jte sets Compute K of Xte via Equation (6) for the hidden-layer neuron powers N and their activation functions c Find the optimal W, N and c through BWASD for Xtr and Dtr Set C the data containing the explanatory variables and J the target Compute Ĵte via Equation (8) (b) Procedure for predicting with the BWASD neural network.

Figure 3 .
Figure 3.The BWASD algorithm and the procedure for predicting with the BWASD neural network.
Testing set results.